home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / GRAPHICS / VOXRAY.ZIP / RAYREND.H < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-29  |  5.2 KB  |  210 lines

  1. #include "ray.h"
  2. #include "fixed.h"
  3. #include "rayrt.h"
  4. #include "slopes.h"
  5. #include "globals.h"
  6. #include "abs.h"
  7. #include <stddef.h>
  8. #include "verttan.h"
  9.  
  10. #define MIN_SLOPE_DIFF 5000
  11. #define MAX_WALL_RUNS 8000
  12. #define MAX_FLOOR_RUNS 4000
  13.  
  14. extern "C" MYFIXED
  15. Win_Top_Sum, Win_Height_Sum,
  16. Win_Top_Increment, Win_Height_Increment;
  17.  
  18. extern "C" long cur_angle_diff, intercept;
  19.  
  20. extern "C" long render_x, render_y, render_z, render_view_angle;
  21.  
  22. extern "C" MYFIXED vec_int_x, vec_int_y;
  23.  
  24. extern "C" short WINDOW_LEFT, WINDOW_RIGHT;
  25.  
  26. extern "C" long rotate_x, rotate_y, rotate_angle;
  27.  
  28. extern "C" long int_x_diff;
  29.  
  30. extern "C" long ray_slope;
  31.  
  32. extern "C" long int_y_diff;
  33.  
  34. extern "C" floor_run_info * floor_runs;
  35.  
  36. extern "C" long floor_run_count;
  37.  
  38. extern "C" wall_run_info * wall_runs;
  39.  
  40. extern "C" long wall_run_count;
  41.  
  42. inline short Get_Wall_Texture_Height(ptexture index) {
  43.    return wall[index].height;
  44. }
  45.  
  46. inline short Get_Floor_Texture_Height(ptexture index) {
  47.    return floortex[index].height;
  48. }
  49.  
  50. inline short Get_Sprite_Texture_Height(ptexture index) {
  51.    return wall[index].height;
  52. }
  53.  
  54. inline short Get_Wall_Texture_Width(ptexture index) {
  55.    return wall[index].width;
  56. }
  57.  
  58. inline short Get_Floor_Texture_Width(ptexture index) {
  59.    return floortex[index].width;
  60. }
  61. inline short Get_Sprite_Texture_Width(ptexture index) {
  62.    return wall[index].width;
  63. }
  64.  
  65. inline Byte Get_Wall_Texture_Shift(ptexture index) {
  66.    return wall[index].shift;
  67. }
  68.  
  69. inline Byte Get_Floor_Texture_Shift(ptexture index) {
  70.    return floortex[index].shift;
  71. }
  72.  
  73. inline Byte Get_Sprite_Texture_Shift(ptexture index) {
  74.    return wall[index].shift;
  75. }
  76.  
  77. inline Byte * Get_Wall_Texture(ptexture index) {
  78.    return wall[index].images[wall[index].cur_image];
  79. }
  80.  
  81. inline Byte * Get_Sprite_Texture(ptexture index, short cur_anim) {
  82.    return wall[index].images[cur_anim];
  83. }
  84.  
  85. inline Byte * Get_Floor_Texture(ptexture index) {
  86.    return floortex[index].images[floortex[index].cur_image];
  87. }
  88.  
  89. inline Byte SecLight(sector * sec)
  90. {
  91. return (UCHAR)(sec->light & (UCHAR)SEC_LIGHT_MASK);
  92. }
  93.  
  94. inline Byte SecLTSpeed(sector * sec)
  95. {
  96. return (UCHAR)((sec->light & (UCHAR)SEC_LTSPEED_MASK) >> (UCHAR)SEC_LTSPEED_SHIFT);
  97. }
  98.  
  99. inline MYFIXED RotateX() {
  100.    return (rotate_x*rcos_table[rotate_angle]+rotate_y*rsin_table[rotate_angle]);
  101. }
  102.  
  103. inline MYFIXED FixedRotateX() {
  104.    return (fixedmult(rotate_x,rcos_table[rotate_angle])+
  105.         fixedmult(rotate_y,rsin_table[rotate_angle]));
  106. }
  107.  
  108. inline MYFIXED RotateY() {
  109.    return (rotate_y*rcos_table[rotate_angle]-rotate_x*rsin_table[rotate_angle]);
  110. }
  111.  
  112. inline MYFIXED FixedRotateY() {
  113.    return (fixedmult(rotate_y,rcos_table[rotate_angle])-
  114.         fixedmult(rotate_x,rsin_table[rotate_angle]));
  115. }
  116.  
  117. inline short Project(MYFIXED x, MYFIXED y) {
  118.    return (fixedmd(-x, SCALE_FACTOR, y) )+WINDOW_MIDDLEW;
  119. }
  120.  
  121. inline sector * GetOppSec(seg * cur_seg)
  122. {
  123. sidedef * cur_sd=cur_seg->ld->s[!(short)cur_seg->left_sidedef];
  124. if (cur_sd != NULL) {
  125.    return cur_sd->sec;
  126. } else {
  127.    return NULL;
  128. }
  129. }
  130.  
  131. inline MYFIXED GetCeilScVal(sector * sec, long distance)
  132. {
  133. if (distance<0)
  134.    return MAXMYFIXED;
  135. if (distance>=(MAXDIS<<SHIFT))
  136.    return (WINDOW_MIDDLE<<SHIFT);
  137. return fixedmult((((render_z-sec->ceil_height)<<SHIFT)+
  138.         fixedmult(distance, vert_angle_tangent)),fixeddiv(y_trans, distance))+
  139.         (WINDOW_MIDDLE << SHIFT);
  140. }
  141.  
  142. inline MYFIXED GetFloorScVal(sector * sec, long distance)
  143. {
  144. if (distance<0)
  145.    return MAXMYFIXED;
  146. if (distance>=(MAXDIS<<SHIFT))
  147.    return (WINDOW_MIDDLE<<SHIFT);
  148. return fixedmult((((render_z-sec->floor_height)<<SHIFT)+
  149.         fixedmult(distance, vert_angle_tangent)),fixeddiv(y_trans, distance))+
  150.         (WINDOW_MIDDLE << SHIFT);
  151. }
  152.  
  153. inline MYFIXED GetZScVal(long z, long distance)
  154. {
  155. if (distance<0)
  156.    return MAXMYFIXED;
  157. if (distance>=(MAXDIS<<SHIFT))
  158.    return (WINDOW_MIDDLE<<SHIFT);
  159. return fixedmult((((render_z-z)<<SHIFT)+
  160.         fixedmult(distance, vert_angle_tangent)),fixeddiv(y_trans, distance))+
  161.         (WINDOW_MIDDLE << SHIFT);
  162. }
  163.  
  164. inline void Setup_Intersection(pvector2 base_v, pvector2 dest_v)
  165. {
  166.    long x_diff, y_diff;
  167.    x_diff=dest_v->x-base_v->x;
  168.    int_x_diff=x_diff;
  169.    y_diff=dest_v->y-base_v->y;
  170.    fixedmult64(y_diff, base_v->x);
  171.    fixedma64(-x_diff, base_v->y);
  172.    int_y_diff=y_diff;
  173. }
  174.  
  175. inline long Get_Intersection_Y(short ray)
  176. {
  177. ray_slope=Get_Slope(ray);
  178. MYFIXED ray_x_diff=fixedmult(ray_slope,int_y_diff);
  179.    if (ABS(ray_x_diff-int_x_diff)>MIN_SLOPE_DIFF)
  180.       vec_int_y=fixeddiv64(ray_x_diff - int_x_diff);
  181.    else vec_int_y=MAXDIS;
  182. return vec_int_y;
  183. }
  184.  
  185. inline long Get_Intersection_X()
  186. {
  187.    vec_int_x=fixedmult(vec_int_y, ray_slope);
  188.    return vec_int_x;
  189. }
  190.  
  191. inline sector * GetSecFromSSec(ssector * cur_ss)
  192. {
  193.    seg * cur_seg=Seg_List+cur_ss->seg_start;
  194.    return (cur_seg->ld->s[(short)cur_seg->left_sidedef]->sec);
  195. }
  196.  
  197. inline sector * GetSecFromSeg(seg * cur_seg)
  198. {
  199.    return (cur_seg->ld->s[(short)cur_seg->left_sidedef]->sec);
  200. }
  201.  
  202. void BSP_Recursion_Draw();
  203. void Draw_Sub_Sector(pssector cur_ss);
  204. void Draw_Sub_Sector_Setup();
  205. void Draw_Sub_Sector_Close();
  206. void Translate_Vectors();
  207. void Ray_Caster(long x, long y, long z, long view_angle);
  208. void Render_2d(long x, long y, long view_angle);
  209. void Draw_SS_Sprites(pssector cur_ss);
  210.